데코레이터 패턴 구현: 파이썬에서의 함수 래핑과 메타데이터 보존 비교

            def simple_logger_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling function: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Finished calling function: {func.__name__}")
        return result
    return wrapper

@simple_logger_decorator
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))

            

              
                Copy
              
            
          

            
Calling function: greet
Hello, Alice!
Finished calling function: greet

            

              
                Copy
              
            
          

            print(f"Function name: {greet.__name__}")
print(f"Docstring: {greet.__doc__}")

            

              
                Copy
              
            
          

            
Function name: wrapper
Docstring: None

            

              
                Copy
              
            
          

            import functools

def preserved_logger_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling function: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Finished calling function: {func.__name__}")
        return result
    return wrapper

@preserved_logger_decorator
def greet_with_preservation(name):
    """Greets a person by name."""
    return f"Hello, {name}!"

print(greet_with_preservation("Bob"))

print(f"Function name: {greet_with_preservation.__name__}")
print(f"Docstring: {greet_with_preservation.__doc__}")

            

              
                Copy
              
            
          

            
Calling function: greet_with_preservation
Hello, Bob!
Finished calling function: greet_with_preservation
Function name: greet_with_preservation
Docstring: Greets a person by name.

            

              
                Copy
              
            
          

            import functools

def requires_admin_role(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        current_user = kwargs.get('user') # Assuming user info is passed as a keyword argument
        if current_user and current_user.role == 'admin':
            return func(*args, **kwargs)
        else:
            return "Access Denied: Administrator role required."
    return wrapper

class User:
    def __init__(self, name, role):
        self.name = name
        self.role = role

@requires_admin_role
def delete_user(user_id, user):
    return f"User {user_id} deleted by {user.name}."

admin_user = User("GlobalAdmin", "admin")
regular_user = User("RegularUser", "user")

# Example calls with metadata preserved
print(delete_user(101, user=admin_user))
print(delete_user(102, user=regular_user))

# Introspection of the decorated function
print(f"Decorated function name: {delete_user.__name__}")
print(f"Decorated function docstring: {delete_user.__doc__}")

            

              
                Copy
              
            
          

            import functools
import time

def timing_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Function '{func.__name__}' took {end_time - start_time:.4f} seconds to execute.")
        return result
    return wrapper

@timing_decorator
def complex_calculation(n):
    """Performs a computationally intensive task."""
    time.sleep(1) # Simulate work
    return sum(i*i for i in range(n))

result = complex_calculation(100000)
print(f"Calculation result: {result}")

print(f"Timing function name: {complex_calculation.__name__}")
print(f"Timing function docstring: {complex_calculation.__doc__}")

            

              
                Copy
              
            
          

            import functools

def simple_cache_decorator(func):
    cache = {}
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # Create a cache key. For simplicity, only consider positional args.
        # A real-world cache would need more sophisticated key generation,
        # especially for kwargs and mutable types.
        key = args
        if key in cache:
            print(f"Cache hit for '{func.__name__}' with args {args}")
            return cache[key]
        else:
            print(f"Cache miss for '{func.__name__}' with args {args}")
            result = func(*args, **kwargs)
            cache[key] = result
            return result
    return wrapper

@simple_cache_decorator
def fibonacci(n):
    """Calculates the nth Fibonacci number recursively."""
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(f"Fibonacci(10): {fibonacci(10)}")
print(f"Fibonacci(10) again: {fibonacci(10)}") # This should be a cache hit

print(f"Fibonacci function name: {fibonacci.__name__}")
print(f"Fibonacci function docstring: {fibonacci.__doc__}")

            

              
                Copy
              
            
          

            import functools

def validate_positive_integer(param_name):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            param_index = -1
            try:
                # Find the index of the parameter by name for positional arguments
                param_index = func.__code__.co_varnames.index(param_name)
                if param_index < len(args):
                    value = args[param_index]
                    if not isinstance(value, int) or value <= 0:
                        raise ValueError(f"'{param_name}' must be a positive integer.")
            except ValueError:
                # If not found as positional, check keyword arguments
                if param_name in kwargs:
                    value = kwargs[param_name]
                    if not isinstance(value, int) or value <= 0:
                        raise ValueError(f"'{param_name}' must be a positive integer.")
                else:
                    # Parameter not found, or it's optional and not provided
                    # Depending on requirements, you might want to raise an error here too
                    pass

            return func(*args, **kwargs)
        return wrapper
    return decorator

@validate_positive_integer('count')
def process_items(items, count):
    """Processes a list of items a specified number of times."""
    print(f"Processing {len(items)} items, {count} times.")
    return len(items) * count

print(process_items(['a', 'b'], count=5))
try:
    process_items(['c'], count=-2)
except ValueError as e:
    print(e)
try:
    process_items(['d'], count='three')
except ValueError as e:
    print(e)

print(f"Validation function name: {process_items.__name__}")
print(f"Validation function docstring: {process_items.__doc__}")

            

              
                Copy
              
            
          

            import functools

def repeat(num_times):
    def decorator_repeat(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator_repeat

@repeat(num_times=3)
def say_hello(name):
    """Prints a greeting."""
    print(f"Hello, {name}!")

say_hello("World")

print(f"Repeat function name: {say_hello.__name__}")
print(f"Repeat function docstring: {say_hello.__doc__}")

            

              
                Copy